// Copyright 2023 Specter Ops, Inc.
//
// Licensed under the Apache License, Version 2.0
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/specterops/bloodhound/log (interfaces: Event)

// Package mocks is a generated GoMock package.
package mocks

import (
	net "net"
	reflect "reflect"
	time "time"

	log "github.com/specterops/bloodhound/log"
	gomock "go.uber.org/mock/gomock"
)

// MockEvent is a mock of Event interface.
type MockEvent struct {
	ctrl     *gomock.Controller
	recorder *MockEventMockRecorder
}

// MockEventMockRecorder is the mock recorder for MockEvent.
type MockEventMockRecorder struct {
	mock *MockEvent
}

// NewMockEvent creates a new mock instance.
func NewMockEvent(ctrl *gomock.Controller) *MockEvent {
	mock := &MockEvent{ctrl: ctrl}
	mock.recorder = &MockEventMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockEvent) EXPECT() *MockEventMockRecorder {
	return m.recorder
}

// Any mocks base method.
func (m *MockEvent) Any(arg0 string, arg1 interface{}) log.Event {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Any", arg0, arg1)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Any indicates an expected call of Any.
func (mr *MockEventMockRecorder) Any(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Any", reflect.TypeOf((*MockEvent)(nil).Any), arg0, arg1)
}

// Bool mocks base method.
func (m *MockEvent) Bool(arg0 string, arg1 ...bool) log.Event {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Bool", varargs...)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Bool indicates an expected call of Bool.
func (mr *MockEventMockRecorder) Bool(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bool", reflect.TypeOf((*MockEvent)(nil).Bool), varargs...)
}

// Bytes mocks base method.
func (m *MockEvent) Bytes(arg0 string, arg1 []byte) log.Event {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Bytes", arg0, arg1)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Bytes indicates an expected call of Bytes.
func (mr *MockEventMockRecorder) Bytes(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bytes", reflect.TypeOf((*MockEvent)(nil).Bytes), arg0, arg1)
}

// Caller mocks base method.
func (m *MockEvent) Caller(arg0 ...int) log.Event {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Caller", varargs...)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Caller indicates an expected call of Caller.
func (mr *MockEventMockRecorder) Caller(arg0 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Caller", reflect.TypeOf((*MockEvent)(nil).Caller), arg0...)
}

// Discard mocks base method.
func (m *MockEvent) Discard() log.Event {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Discard")
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Discard indicates an expected call of Discard.
func (mr *MockEventMockRecorder) Discard() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Discard", reflect.TypeOf((*MockEvent)(nil).Discard))
}

// Duration mocks base method.
func (m *MockEvent) Duration(arg0 string, arg1 ...time.Duration) log.Event {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Duration", varargs...)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Duration indicates an expected call of Duration.
func (mr *MockEventMockRecorder) Duration(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Duration", reflect.TypeOf((*MockEvent)(nil).Duration), varargs...)
}

// Enabled mocks base method.
func (m *MockEvent) Enabled() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Enabled")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Enabled indicates an expected call of Enabled.
func (mr *MockEventMockRecorder) Enabled() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Enabled", reflect.TypeOf((*MockEvent)(nil).Enabled))
}

// Fault mocks base method.
func (m *MockEvent) Fault(arg0 ...error) log.Event {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Fault", varargs...)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Fault indicates an expected call of Fault.
func (mr *MockEventMockRecorder) Fault(arg0 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fault", reflect.TypeOf((*MockEvent)(nil).Fault), arg0...)
}

// Float32 mocks base method.
func (m *MockEvent) Float32(arg0 string, arg1 ...float32) log.Event {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Float32", varargs...)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Float32 indicates an expected call of Float32.
func (mr *MockEventMockRecorder) Float32(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Float32", reflect.TypeOf((*MockEvent)(nil).Float32), varargs...)
}

// Float64 mocks base method.
func (m *MockEvent) Float64(arg0 string, arg1 ...float64) log.Event {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Float64", varargs...)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Float64 indicates an expected call of Float64.
func (mr *MockEventMockRecorder) Float64(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Float64", reflect.TypeOf((*MockEvent)(nil).Float64), varargs...)
}

// Hex mocks base method.
func (m *MockEvent) Hex(arg0 string, arg1 []byte) log.Event {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Hex", arg0, arg1)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Hex indicates an expected call of Hex.
func (mr *MockEventMockRecorder) Hex(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Hex", reflect.TypeOf((*MockEvent)(nil).Hex), arg0, arg1)
}

// IPAddr mocks base method.
func (m *MockEvent) IPAddr(arg0 string, arg1 net.IP) log.Event {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IPAddr", arg0, arg1)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// IPAddr indicates an expected call of IPAddr.
func (mr *MockEventMockRecorder) IPAddr(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IPAddr", reflect.TypeOf((*MockEvent)(nil).IPAddr), arg0, arg1)
}

// IPPrefix mocks base method.
func (m *MockEvent) IPPrefix(arg0 string, arg1 net.IPNet) log.Event {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IPPrefix", arg0, arg1)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// IPPrefix indicates an expected call of IPPrefix.
func (mr *MockEventMockRecorder) IPPrefix(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IPPrefix", reflect.TypeOf((*MockEvent)(nil).IPPrefix), arg0, arg1)
}

// Int mocks base method.
func (m *MockEvent) Int(arg0 string, arg1 ...int) log.Event {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Int", varargs...)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Int indicates an expected call of Int.
func (mr *MockEventMockRecorder) Int(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Int", reflect.TypeOf((*MockEvent)(nil).Int), varargs...)
}

// Int16 mocks base method.
func (m *MockEvent) Int16(arg0 string, arg1 ...int16) log.Event {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Int16", varargs...)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Int16 indicates an expected call of Int16.
func (mr *MockEventMockRecorder) Int16(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Int16", reflect.TypeOf((*MockEvent)(nil).Int16), varargs...)
}

// Int32 mocks base method.
func (m *MockEvent) Int32(arg0 string, arg1 ...int32) log.Event {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Int32", varargs...)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Int32 indicates an expected call of Int32.
func (mr *MockEventMockRecorder) Int32(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Int32", reflect.TypeOf((*MockEvent)(nil).Int32), varargs...)
}

// Int64 mocks base method.
func (m *MockEvent) Int64(arg0 string, arg1 ...int64) log.Event {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Int64", varargs...)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Int64 indicates an expected call of Int64.
func (mr *MockEventMockRecorder) Int64(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Int64", reflect.TypeOf((*MockEvent)(nil).Int64), varargs...)
}

// Int8 mocks base method.
func (m *MockEvent) Int8(arg0 string, arg1 ...int8) log.Event {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Int8", varargs...)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Int8 indicates an expected call of Int8.
func (mr *MockEventMockRecorder) Int8(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Int8", reflect.TypeOf((*MockEvent)(nil).Int8), varargs...)
}

// MACAddr mocks base method.
func (m *MockEvent) MACAddr(arg0 string, arg1 net.HardwareAddr) log.Event {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MACAddr", arg0, arg1)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// MACAddr indicates an expected call of MACAddr.
func (mr *MockEventMockRecorder) MACAddr(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MACAddr", reflect.TypeOf((*MockEvent)(nil).MACAddr), arg0, arg1)
}

// Msg mocks base method.
func (m *MockEvent) Msg(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Msg", arg0)
}

// Msg indicates an expected call of Msg.
func (mr *MockEventMockRecorder) Msg(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Msg", reflect.TypeOf((*MockEvent)(nil).Msg), arg0)
}

// Msgf mocks base method.
func (m *MockEvent) Msgf(arg0 string, arg1 ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Msgf", varargs...)
}

// Msgf indicates an expected call of Msgf.
func (mr *MockEventMockRecorder) Msgf(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Msgf", reflect.TypeOf((*MockEvent)(nil).Msgf), varargs...)
}

// Send mocks base method.
func (m *MockEvent) Send() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Send")
}

// Send indicates an expected call of Send.
func (mr *MockEventMockRecorder) Send() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockEvent)(nil).Send))
}

// Stack mocks base method.
func (m *MockEvent) Stack() log.Event {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Stack")
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Stack indicates an expected call of Stack.
func (mr *MockEventMockRecorder) Stack() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stack", reflect.TypeOf((*MockEvent)(nil).Stack))
}

// Str mocks base method.
func (m *MockEvent) Str(arg0 string, arg1 ...string) log.Event {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Str", varargs...)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Str indicates an expected call of Str.
func (mr *MockEventMockRecorder) Str(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Str", reflect.TypeOf((*MockEvent)(nil).Str), varargs...)
}

// Time mocks base method.
func (m *MockEvent) Time(arg0 string, arg1 ...time.Time) log.Event {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Time", varargs...)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Time indicates an expected call of Time.
func (mr *MockEventMockRecorder) Time(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Time", reflect.TypeOf((*MockEvent)(nil).Time), varargs...)
}

// TimeDiff mocks base method.
func (m *MockEvent) TimeDiff(arg0 string, arg1, arg2 time.Time) log.Event {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TimeDiff", arg0, arg1, arg2)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// TimeDiff indicates an expected call of TimeDiff.
func (mr *MockEventMockRecorder) TimeDiff(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TimeDiff", reflect.TypeOf((*MockEvent)(nil).TimeDiff), arg0, arg1, arg2)
}

// Timestamp mocks base method.
func (m *MockEvent) Timestamp() log.Event {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Timestamp")
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Timestamp indicates an expected call of Timestamp.
func (mr *MockEventMockRecorder) Timestamp() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockEvent)(nil).Timestamp))
}

// Uint mocks base method.
func (m *MockEvent) Uint(arg0 string, arg1 ...uint) log.Event {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Uint", varargs...)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Uint indicates an expected call of Uint.
func (mr *MockEventMockRecorder) Uint(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Uint", reflect.TypeOf((*MockEvent)(nil).Uint), varargs...)
}

// Uint16 mocks base method.
func (m *MockEvent) Uint16(arg0 string, arg1 ...uint16) log.Event {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Uint16", varargs...)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Uint16 indicates an expected call of Uint16.
func (mr *MockEventMockRecorder) Uint16(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Uint16", reflect.TypeOf((*MockEvent)(nil).Uint16), varargs...)
}

// Uint32 mocks base method.
func (m *MockEvent) Uint32(arg0 string, arg1 ...uint32) log.Event {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Uint32", varargs...)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Uint32 indicates an expected call of Uint32.
func (mr *MockEventMockRecorder) Uint32(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Uint32", reflect.TypeOf((*MockEvent)(nil).Uint32), varargs...)
}

// Uint64 mocks base method.
func (m *MockEvent) Uint64(arg0 string, arg1 ...uint64) log.Event {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Uint64", varargs...)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Uint64 indicates an expected call of Uint64.
func (mr *MockEventMockRecorder) Uint64(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Uint64", reflect.TypeOf((*MockEvent)(nil).Uint64), varargs...)
}

// Uint8 mocks base method.
func (m *MockEvent) Uint8(arg0 string, arg1 ...byte) log.Event {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Uint8", varargs...)
	ret0, _ := ret[0].(log.Event)
	return ret0
}

// Uint8 indicates an expected call of Uint8.
func (mr *MockEventMockRecorder) Uint8(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Uint8", reflect.TypeOf((*MockEvent)(nil).Uint8), varargs...)
}
